function NW04_mb_gj() {

}

// 字符串叠加
NW04_mb_gj.prototype._diejia = function (zhi, zhi1, zhi2, zhi3, zhi4) {
    if (!zhi) {
        zhi = '';
    }
    if (null != zhi1 && zhi1 != '') {
        zhi += zhi1;
    }
    if (null != zhi2 && zhi2 != '') {
        zhi += zhi2;
    }
    if (null != zhi3 && zhi3 != '') {
        zhi += zhi3;
    }
    if (null != zhi4 && zhi4 != '') {
        zhi += zhi4;
    }

    return zhi;
}

/**
 * 移动到一个 变量模板的 开始处
 * 
 *  假设传入字符串为 aaaaaaaaa{{dizhi}}?q=abc
 *   
 * 结果为：
 *   YuanS: (3) ['aaaaaaaaa', 'dizhi', '?q=abc']
 *   YBS: [1] , YBS[1]的值为 1， 即，表示 YuanS[1]的值，是变量名
 * 
 * @param {数字} yb0 开始游标
 * @param {数组} zifuchuan 源字符串
 * @返回  {null|数组} 解释后的 字符串，和变量名。
 */
NW04_mb_gj.prototype.fenxi = function (zifuchuan) {
    if (!zifuchuan || zifuchuan.length == 0) {
        return null;
    }
    let _ShujuS = zifuchuan.split('');//源数组
    //最大的游标
    let zdYB = _ShujuS.length - 1;
    //存放结果
    let jg = {
        yb: 0,
        YuanS: [],//存放 原始数据
        YBS: [], //存放 游标 指定 YuanS 哪个元素是变量名（需要替换掉的）
        ftj: function (zhi) {
            this.YuanS.push(zhi);
            this.yb++;
        },
        ftjBL: function (zhi) {
            if (zhi) {
                this.YuanS.push(zhi);
                this.YBS.push(this.yb);
                this.yb++;
            }
        }
    }

    let _rq = 0;         //p=1 字符串值  ；b=2 变量;

    //p阵营
    let _pZhi = null;       //字符串值
    //b阵营
    let _bZhi = null;       //变量 用于存放变量模板中，变量名  {{变量名}}
    let _bo = -1;           //记录最后一个{的下标

    let dzf = null;       //单字符;
    for (let i = 0; i < _ShujuS.length; i++) {
        dzf = _ShujuS[i];
        //这次循环，是最后一次循环，不可能组成 }} 变量模板的 结束符。
        //因为，每次碰到 符号{   或   符号}，总是取 i+1 个字符判断，是开头，还是结束。
        if (i + 1 > zdYB) {
            _pZhi = this._diejia(_pZhi, (_rq == 2 ? '{{' : ''), _bZhi, dzf);
            if (_pZhi != null && _pZhi != '') {
                jg.ftj(_pZhi);
            }
            break;//结束循环
        }

        switch (dzf) {
            case '{'://表示开始
                if (_rq == 1) {//当前是 普通阵营 在接收值
                    //2、判断下一个字符，是不是{,如果是{ , 组成新的开始标识。
                    dzf = _ShujuS[++i];
                    if (dzf == '{') {//表示 连续的 {{ ,暂时定为 变量模板的开始。
                        _bo = i;        //记录最后坐标
                        _rq = 2         //交给 变量阵营 接收值。
                    } else {//无法组成新的开始符。
                        _pZhi = this._diejia(_pZhi, '{', dzf);//依然是 普通阵营 在接收值
                    }
                } else if (_rq == 2) { //当前是 变量阵营 在接收值
                    //首先判断，是不是连续的
                    if (_bo == (i - 1)) {//如果 连续性的 比如：{{{{
                        _pZhi = this._diejia(_pZhi, '{');//推送一个到p阵营。
                        _bo = i;//记录最新的{位置
                    } else {//如果不是连续性的 {{{
                        //2、判断下一个字符，是不是{,如果是{ , 组成新的开始标识。
                        dzf = _ShujuS[++i];
                        if (dzf == '{') {//表示 连续的 {{ ,暂时定为 变量模板的开始。
                            //1.1、转移 之前_bZhi的旧数据
                            _pZhi = this._diejia(_pZhi, '{{', _bZhi);
                            //1.2、清空
                            _bZhi = null;
                            _bo = i;//记录最后坐标
                            // _rq=2//不变，还是当前的 阵营在接收值
                        } else {//无法组成新的开始符。
                            //1.1、转移 变量阵营的数据 到 普通阵营。（因为变量阵营 无法组成 完整的变量）
                            _pZhi = this._diejia(_pZhi, '{{', _bZhi, '{', dzf);
                            //1.2、清空
                            _bZhi = null;
                            _rq = 1;//交给 普通阵营接收值。
                        }
                    }
                } else {//表示没指明 是哪个 阵营在 接收值
                    dzf = _ShujuS[++i]; //2、判断下一个字符,如果是{ , 组成新的开始标识。
                    if (dzf == '{') {   //表示 连续的 {{ ,暂时定为 变量模板的开始。
                        _rq = 2;        //表示 接下来，是变量阵营 接收值
                        _bo = i;        //记录  变量阵营 接管时间点（数组下标）
                    } else {
                        _rq = 1;        //无法组成 变量开始 符号。定为 普通阵营。
                        _pZhi = this._diejia(_pZhi, '{', dzf);//推送一个到  普通阵营。
                    }
                }
                continue;
            case ' ':
                if (_rq == 1) {
                    _pZhi = this._diejia(_pZhi, ' ');
                }
                continue;
            case '}':
                if (_rq == 1) { //如果是普通阵营在接收值，依然当普通值接收
                    _pZhi = this._diejia(_pZhi, '}');

                } else if (_rq == 2) {//如果是 变量阵营 在接收值， 那么，检测下一个字符，是不是 }
                    dzf = _ShujuS[++i];//下一个字符串
                    if (dzf == '}') {//如果也是} ，那么，组成了 }} 变量结束符。
                        if (null != _pZhi) {
                            jg.ftj(_pZhi)
                        }
                        jg.ftjBL(_bZhi);//变量名。
                        //重新定位
                        _rq = 0;//未知类型。要看下一个字符是什么
                        _bo = -1;
                        _pZhi = null;
                        _bZhi = null;
                    } else {
                        //将 变量阵营 转移到普通阵营。因为，它们无法组成 一个完整的变量
                        _pZhi = this._diejia(_pZhi, '{{', _bZhi, '}', dzf);//把开始符，变量缓存值，},及下个字符dzf，转移到普通阵营

                        //重新定位
                        _rq = 0;//未知类型。要看下一个字符是什么
                        _bo = -1;
                        _bZhi = null;
                    }
                } else {
                    _rq = 1;
                    _pZhi = this._diejia(_pZhi, '}');//表示，文本以 }开头。
                }
                continue;
            default:
                if (_rq == 1) { //如果是普通阵营在接收值，依然当普通值接收
                    _pZhi = this._diejia(_pZhi, dzf);
                } else if (_rq == 2) {//如果是 变量阵营 在接收值
                    _bZhi = this._diejia(_bZhi, dzf);
                } else {
                    _rq = 1;
                    _pZhi = this._diejia(_pZhi, dzf);//表示，文本
                }
        }
    }
    return jg;
}
